package thinkinjava1.ch08;

import java.util.*;

/**
 * Created by 顾博君 on 2017/2/21.
 */

public class List1 {
    public static List fill(List a) {
        return (List) Collection1.fill(a);
    }

    public static void print(List a) {
        for (int i = 0; i < a.size(); i++)
            System.out.print(a.get(i) + " ");
        System.out.println();
    }

    static boolean b;
    static Object o;
    static int i;
    static Iterator it;
    static ListIterator lit;

    public static void basicTest(List a) {
        a.add(1, "x");
        a.add("x");
        a.addAll(fill(new ArrayList()));
        a.addAll(3, fill(new ArrayList()));
        b = a.contains("1");
        b = a.containsAll(fill((new ArrayList())));
        o = a.get(1); // Get object at location 1
        i = a.indexOf("1"); // Tell index of object
// indexOf, starting search at location 2:
        b = a.isEmpty(); // Any elements inside?
        it = a.iterator(); // Ordinary Iterator
        lit = a.listIterator(); // ListIterator
        lit = a.listIterator(3); // Start at loc 3
        i = a.lastIndexOf("1"); // Last match
        a.remove(1); // Remove location 1
        a.remove("3"); // Remove this object
        a.set(1, "y"); // Set1 location 1 to "y"
// Keep everything that's in the argument
// (the intersection of the two sets):
        a.retainAll(fill(new ArrayList()));
// Remove everything that's in the argument:
        a.removeAll(fill(new ArrayList()));
        i = a.size(); // How big is it?
        a.clear(); // Remove all elements
    }

    public static void iterMotion(List a) {
        ListIterator it = a.listIterator();
        b = it.hasNext();
        b = it.hasPrevious();
        o = it.next();
        i = it.nextIndex();
        o = it.previous();
        i = it.previousIndex();
    }

    public static void iterManipulation(List a) {
        ListIterator it = a.listIterator();
        it.add("47");
// Must move to an element after add():
        it.next();
        // Remove the element that was just produced:
        it.remove();
// Must move to an element after remove():
        it.next();
// Change the element that was just produced:
        it.set("47");
    }

    public static void testVisual(List a) {
        print(a);
        List b = new ArrayList();
        fill(b);
        System.out.print("b = ");
        print(b);
        a.addAll(b);
        a.addAll(fill(new ArrayList()));
        print(a);
// Shrink the list by removing all the
// elements beyond the first 1/2 of the list
        System.out.println(a.size());
        System.out.println(a.size() / 2);
        print(a);
// Insert, remove, and replace elements
// using a ListIterator:
        ListIterator x = a.listIterator(a.size() / 2);
        x.add("one");
        print(a);
        System.out.println(x.next());
        x.remove();
        System.out.println(x.next());
        x.set("47");
        print(a);
// Traverse the list backwards:
        x = a.listIterator(a.size());
        while (x.hasPrevious())
            System.out.print(x.previous() + " ");
        System.out.println();
        System.out.println("testVisual finished");
    }

    // There are some things that only
// LinkedLists can do:
    public static void testLinkedList() {
        LinkedList ll = new LinkedList();
        Collection1.fill(ll, 5);
        print(ll);
// Treat it like a stack, pushing:
        ll.addFirst("one");
        ll.addFirst("two");
        print(ll);
// Like "peeking" at the top of a stack:
        System.out.println(ll.getFirst());
// Like popping a stack:
        System.out.println(ll.removeFirst());
        System.out.println(ll.removeFirst());
// Treat it like a queue, pulling elements
// off the tail end:
        System.out.println(ll.removeLast());

        // With the above operations, it's a dequeue!
        print(ll);
    }

    public static void main(String[] args) {
// Make and fill a new list each time:
        basicTest(fill(new LinkedList()));
        basicTest(fill(new ArrayList()));
        iterMotion(fill(new LinkedList()));
        iterMotion(fill(new ArrayList()));
        iterManipulation(fill(new LinkedList()));
        iterManipulation(fill(new ArrayList()));
        testVisual(fill(new LinkedList()));
        testLinkedList();
    }
}
